home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / utils / file / fileutil.13 / fileutil / fileutils-3.13 / lib / mountlist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-22  |  12.3 KB  |  518 lines
  1. /* mountlist.c -- return a list of mounted filesystems
  2.    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. #ifdef HAVE_CONFIG_H
  19. #include <config.h>
  20. #endif
  21.  
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include "mountlist.h"
  25.  
  26. #ifdef STDC_HEADERS
  27. #include <stdlib.h>
  28. #else
  29. void free ();
  30. #endif
  31. #if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
  32. #include <string.h>
  33. #else
  34. #include <strings.h>
  35. #endif
  36.  
  37. char *strstr ();
  38. char *xmalloc ();
  39. char *xrealloc ();
  40. char *xstrdup ();
  41. void error ();
  42.  
  43. #ifdef HAVE_SYS_PARAM_H
  44. #include <sys/param.h>
  45. #endif
  46.  
  47. #if defined (MOUNTED_GETFSSTAT)    /* __alpha running OSF_1 */
  48. #  include <sys/mount.h>
  49. #  include <sys/fs_types.h>
  50. #endif /* MOUNTED_GETFSSTAT */
  51.  
  52. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  53. #include <mntent.h>
  54. #if !defined(MOUNTED)
  55. #  if defined(MNT_MNTTAB)    /* HP-UX.  */
  56. #    define MOUNTED MNT_MNTTAB
  57. #  endif
  58. #  if defined(MNTTABNAME)    /* Dynix.  */
  59. #    define MOUNTED MNTTABNAME
  60. #  endif
  61. #endif
  62. #endif
  63.  
  64. #ifdef MOUNTED_GETMNTINFO    /* 4.4BSD.  */
  65. #include <sys/mount.h>
  66. #endif
  67.  
  68. #ifdef MOUNTED_GETMNT        /* Ultrix.  */
  69. #include <sys/mount.h>
  70. #include <sys/fs_types.h>
  71. #endif
  72.  
  73. #ifdef MOUNTED_FREAD        /* SVR2.  */
  74. #include <mnttab.h>
  75. #endif
  76.  
  77. #ifdef MOUNTED_FREAD_FSTYP    /* SVR3.  */
  78. #include <mnttab.h>
  79. #include <sys/fstyp.h>
  80. #include <sys/statfs.h>
  81. #endif
  82.  
  83. #ifdef MOUNTED_LISTMNTENT
  84. #include <mntent.h>
  85. #endif
  86.  
  87. #ifdef MOUNTED_GETMNTENT2    /* SVR4.  */
  88. #include <sys/mnttab.h>
  89. #endif
  90.  
  91. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  92. #include <fshelp.h>
  93. #include <sys/vfs.h>
  94. #endif
  95.  
  96. #ifdef DOLPHIN
  97. /* So special that it's not worth putting this in autoconf.  */
  98. #undef MOUNTED_FREAD_FSTYP
  99. #define MOUNTED_GETMNTTBL
  100. #endif
  101.  
  102. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  103. /* Return the value of the hexadecimal number represented by CP.
  104.    No prefix (like '0x') or suffix (like 'h') is expected to be
  105.    part of CP. */
  106.  
  107. static int
  108. xatoi (cp)
  109.      char *cp;
  110. {
  111.   int val;
  112.  
  113.   val = 0;
  114.   while (*cp)
  115.     {
  116.       if (*cp >= 'a' && *cp <= 'f')
  117.     val = val * 16 + *cp - 'a' + 10;
  118.       else if (*cp >= 'A' && *cp <= 'F')
  119.     val = val * 16 + *cp - 'A' + 10;
  120.       else if (*cp >= '0' && *cp <= '9')
  121.     val = val * 16 + *cp - '0';
  122.       else
  123.     break;
  124.       cp++;
  125.     }
  126.   return val;
  127. }
  128. #endif /* MOUNTED_GETMNTENT1.  */
  129.  
  130. #if defined (MOUNTED_GETMNTINFO) && !defined (__NetBSD__)
  131. static char *
  132. fstype_to_string (t)
  133.      short t;
  134. {
  135.   switch (t)
  136.     {
  137.     case MOUNT_UFS:
  138.       return "ufs";
  139.     case MOUNT_NFS:
  140.       return "nfs";
  141. #ifdef MOUNT_PC
  142.     case MOUNT_PC:
  143.       return "pc";
  144. #endif
  145. #ifdef MOUNT_MFS
  146.     case MOUNT_MFS:
  147.       return "mfs";
  148. #endif
  149. #ifdef MOUNT_LO
  150.     case MOUNT_LO:
  151.       return "lo";
  152. #endif
  153. #ifdef MOUNT_TFS
  154.     case MOUNT_TFS:
  155.       return "tfs";
  156. #endif
  157. #ifdef MOUNT_TMP
  158.     case MOUNT_TMP:
  159.       return "tmp";
  160. #endif
  161.     default:
  162.       return "?";
  163.     }
  164. }
  165. #endif /* MOUNTED_GETMNTINFO */
  166.  
  167. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  168. static char *
  169. fstype_to_string (t)
  170.      int t;
  171. {
  172.   struct vfs_ent *e;
  173.  
  174.   e = getvfsbytype (t);
  175.   if (!e || !e->vfsent_name)
  176.     return "none";
  177.   else
  178.     return e->vfsent_name;
  179. }
  180. #endif /* MOUNTED_VMOUNT */
  181.  
  182. /* Return a list of the currently mounted filesystems, or NULL on error.
  183.    Add each entry to the tail of the list so that they stay in order.
  184.    If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in
  185.    the returned list are valid.  Otherwise, they might not be.
  186.    If ALL_FS is zero, do not return entries for filesystems that
  187.    are automounter (dummy) entries.  */
  188.  
  189. struct mount_entry *
  190. read_filesystem_list (need_fs_type, all_fs)
  191.      int need_fs_type, all_fs;
  192. {
  193.   struct mount_entry *mount_list;
  194.   struct mount_entry *me;
  195.   struct mount_entry *mtail;
  196.  
  197.   /* Start the list off with a dummy entry. */
  198.   me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  199.   me->me_next = NULL;
  200.   mount_list = mtail = me;
  201.  
  202. #ifdef MOUNTED_LISTMNTENT
  203.   {
  204.     struct tabmntent *mntlist, *p;
  205.     struct mntent *mnt;
  206.     struct mount_entry *me;
  207.     
  208.     /* the third and fourth arguments could be used to filter mounts,
  209.        but Crays doesn't seem to have any mounts that we want to
  210.        remove. Specifically, automount create normal NFS mounts.
  211.        */
  212.  
  213.     if(listmntent(&mntlist, KMTAB, NULL, NULL) < 0)
  214.       return NULL;
  215.     p = mntlist;
  216.     while(p){
  217.       mnt = p->ment;
  218.       me = (struct mount_entry*) xmalloc(sizeof (struct mount_entry));
  219.       me->me_devname = xstrdup(mnt->mnt_fsname);
  220.       me->me_mountdir = xstrdup(mnt->mnt_dir);
  221.       me->me_type = xstrdup(mnt->mnt_type);
  222.       me->me_dev = -1;
  223.       me->me_next = NULL;
  224.       mtail->me_next = me;
  225.       mtail = me;
  226.       p = p->next;
  227.     }
  228.     freemntlist(mntlist);
  229.   }
  230. #endif
  231.  
  232. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  233.   {
  234.     struct mntent *mnt;
  235.     char *table = MOUNTED;
  236.     FILE *fp;
  237.     char *devopt;
  238.  
  239.     fp = setmntent (table, "r");
  240.     if (fp == NULL)
  241.       return NULL;
  242.  
  243.     while ((mnt = getmntent (fp)))
  244.       {
  245.     if (!all_fs && (!strcmp (mnt->mnt_type, "ignore")
  246.             || !strcmp (mnt->mnt_type, "auto")))
  247.       continue;
  248.  
  249.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  250.     me->me_devname = xstrdup (mnt->mnt_fsname);
  251.     me->me_mountdir = xstrdup (mnt->mnt_dir);
  252.     me->me_type = xstrdup (mnt->mnt_type);
  253.     devopt = strstr (mnt->mnt_opts, "dev=");
  254.     if (devopt)
  255.       {
  256.         if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X'))
  257.           me->me_dev = xatoi (devopt + 6);
  258.         else
  259.           me->me_dev = xatoi (devopt + 4);
  260.       }
  261.     else
  262.       me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  263.     me->me_next = NULL;
  264.  
  265.     /* Add to the linked list. */
  266.     mtail->me_next = me;
  267.     mtail = me;
  268.       }
  269.  
  270.     if (endmntent (fp) == 0)
  271.       return NULL;
  272.   }
  273. #endif /* MOUNTED_GETMNTENT1. */
  274.  
  275. #ifdef MOUNTED_GETMNTINFO    /* 4.4BSD.  */
  276.   {
  277.     struct statfs *fsp;
  278.     int entries;
  279.  
  280.     entries = getmntinfo (&fsp, MNT_NOWAIT);
  281.     if (entries < 0)
  282.       return NULL;
  283.     while (entries-- > 0)
  284.       {
  285.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  286.     me->me_devname = xstrdup (fsp->f_mntfromname);
  287.     me->me_mountdir = xstrdup (fsp->f_mntonname);
  288. #ifdef __NetBSD__
  289.     me->me_type = xstrdup (fsp->f_fstypename);
  290. #else
  291.     me->me_type = fstype_to_string (fsp->f_type);
  292. #endif
  293.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  294.     me->me_next = NULL;
  295.  
  296.     /* Add to the linked list. */
  297.     mtail->me_next = me;
  298.     mtail = me;
  299.     fsp++;
  300.       }
  301.   }
  302. #endif /* MOUNTED_GETMNTINFO */
  303.  
  304. #ifdef MOUNTED_GETMNT        /* Ultrix.  */
  305.   {
  306.     int offset = 0;
  307.     int val;
  308.     struct fs_data fsd;
  309.  
  310.     while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY,
  311.               (char *) 0)) > 0)
  312.       {
  313.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  314.     me->me_devname = xstrdup (fsd.fd_req.devname);
  315.     me->me_mountdir = xstrdup (fsd.fd_req.path);
  316.     me->me_type = gt_names[fsd.fd_req.fstype];
  317.     me->me_dev = fsd.fd_req.dev;
  318.     me->me_next = NULL;
  319.  
  320.     /* Add to the linked list. */
  321.     mtail->me_next = me;
  322.     mtail = me;
  323.       }
  324.     if (val < 0)
  325.       return NULL;
  326.   }
  327. #endif /* MOUNTED_GETMNT. */
  328.  
  329. #if defined (MOUNTED_GETFSSTAT)    /* __alpha running OSF_1 */
  330.   {
  331.     int numsys, counter, bufsize;
  332.     struct statfs *stats;
  333.  
  334.     numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT);
  335.     if (numsys < 0)
  336.       return (NULL);
  337.  
  338.     bufsize = (1 + numsys) * sizeof (struct statfs);
  339.     stats = (struct statfs *)xmalloc (bufsize);
  340.     numsys = getfsstat (stats, bufsize, MNT_WAIT);
  341.  
  342.     if (numsys < 0)
  343.       {
  344.     free (stats);
  345.     return (NULL);
  346.       }
  347.  
  348.     for (counter = 0; counter < numsys; counter++)
  349.       {
  350.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  351.     me->me_devname = xstrdup (stats[counter].f_mntfromname);
  352.     me->me_mountdir = xstrdup (stats[counter].f_mntonname);
  353.     me->me_type = mnt_names[stats[counter].f_type];
  354.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  355.     me->me_next = NULL;
  356.  
  357.     /* Add to the linked list. */
  358.     mtail->me_next = me;
  359.     mtail = me;
  360.       }
  361.  
  362.     free (stats);
  363.   }
  364. #endif /* MOUNTED_GETFSSTAT */
  365.  
  366. #if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP) /* SVR[23].  */
  367.   {
  368.     struct mnttab mnt;
  369.     char *table = "/etc/mnttab";
  370.     FILE *fp;
  371.  
  372.     fp = fopen (table, "r");
  373.     if (fp == NULL)
  374.       return NULL;
  375.  
  376.     while (fread (&mnt, sizeof mnt, 1, fp) > 0)
  377.       {
  378.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  379. #ifdef GETFSTYP            /* SVR3.  */
  380.     me->me_devname = xstrdup (mnt.mt_dev);
  381. #else
  382.     me->me_devname = xmalloc (strlen (mnt.mt_dev) + 6);
  383.     strcpy (me->me_devname, "/dev/");
  384.     strcpy (me->me_devname + 5, mnt.mt_dev);
  385. #endif
  386.     me->me_mountdir = xstrdup (mnt.mt_filsys);
  387.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  388.     me->me_type = "";
  389. #ifdef GETFSTYP            /* SVR3.  */
  390.     if (need_fs_type)
  391.       {
  392.         struct statfs fsd;
  393.         char typebuf[FSTYPSZ];
  394.  
  395.         if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1
  396.         && sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1)
  397.           me->me_type = xstrdup (typebuf);
  398.       }
  399. #endif
  400.     me->me_next = NULL;
  401.  
  402.     /* Add to the linked list. */
  403.     mtail->me_next = me;
  404.     mtail = me;
  405.       }
  406.  
  407.     if (fclose (fp) == EOF)
  408.       return NULL;
  409.   }
  410. #endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP.  */
  411.  
  412. #ifdef MOUNTED_GETMNTTBL    /* DolphinOS goes it's own way */
  413.   {
  414.     struct mntent **mnttbl=getmnttbl(),**ent;
  415.     for (ent=mnttbl;*ent;ent++)
  416.       {
  417.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  418.     me->me_devname = xstrdup ( (*ent)->mt_resource);
  419.     me->me_mountdir = xstrdup( (*ent)->mt_directory);
  420.     me->me_type =  xstrdup ((*ent)->mt_fstype);
  421.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  422.     me->me_next = NULL;
  423.  
  424.     /* Add to the linked list. */
  425.     mtail->me_next = me;
  426.     mtail = me;
  427.       }
  428.     endmnttbl();
  429.   }
  430. #endif
  431.  
  432. #ifdef MOUNTED_GETMNTENT2    /* SVR4.  */
  433.   {
  434.     struct mnttab mnt;
  435.     char *table = MNTTAB;
  436.     FILE *fp;
  437.     int ret;
  438.  
  439.     fp = fopen (table, "r");
  440.     if (fp == NULL)
  441.       return NULL;
  442.  
  443.     while ((ret = getmntent (fp, &mnt)) == 0)
  444.       {
  445.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  446.     me->me_devname = xstrdup (mnt.mnt_special);
  447.     me->me_mountdir = xstrdup (mnt.mnt_mountp);
  448.     me->me_type = xstrdup (mnt.mnt_fstype);
  449.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  450.     me->me_next = NULL;
  451.  
  452.     /* Add to the linked list. */
  453.     mtail->me_next = me;
  454.     mtail = me;
  455.       }
  456.  
  457.     if (ret > 0)
  458.       return NULL;
  459.    if (fclose (fp) == EOF)
  460.       return NULL;
  461.   }
  462. #endif /* MOUNTED_GETMNTENT2.  */
  463.  
  464. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  465.   {
  466.     int bufsize;
  467.     char *entries, *thisent;
  468.     struct vmount *vmp;
  469.  
  470.     /* Ask how many bytes to allocate for the mounted filesystem info.  */
  471.     mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize);
  472.     entries = xmalloc (bufsize);
  473.  
  474.     /* Get the list of mounted filesystems.  */
  475.     mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries);
  476.  
  477.     for (thisent = entries; thisent < entries + bufsize;
  478.      thisent += vmp->vmt_length)
  479.       {
  480.     vmp = (struct vmount *) thisent;
  481.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  482.     if (vmp->vmt_flags & MNT_REMOTE)
  483.       {
  484.         char *host, *path;
  485.  
  486.         /* Prepend the remote pathname.  */
  487.         host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
  488.         path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
  489.         me->me_devname = xmalloc (strlen (host) + strlen (path) + 2);
  490.         strcpy (me->me_devname, host);
  491.         strcat (me->me_devname, ":");
  492.         strcat (me->me_devname, path);
  493.       }
  494.     else
  495.       {
  496.         me->me_devname = xstrdup (thisent +
  497.                       vmp->vmt_data[VMT_OBJECT].vmt_off);
  498.       }
  499.     me->me_mountdir = xstrdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off);
  500.     me->me_type = xstrdup (fstype_to_string (vmp->vmt_gfstype));
  501.     me->me_dev = (dev_t) -1; /* vmt_fsid might be the info we want.  */
  502.     me->me_next = NULL;
  503.  
  504.     /* Add to the linked list. */
  505.     mtail->me_next = me;
  506.     mtail = me;
  507.       }
  508.     free (entries);
  509.   }
  510. #endif /* MOUNTED_VMOUNT. */
  511.  
  512.   /* Free the dummy head. */
  513.   me = mount_list;
  514.   mount_list = mount_list->me_next;
  515.   free (me);
  516.   return mount_list;
  517. }
  518.